import { http } from "@/utils/http";
import type { ApiResponse } from "./user";

/** 角色信息 */
export interface Role {
  /** 角色ID */
  id: number;
  /** 角色标识 */
  roleKey: string;
  /** 角色名称 */
  roleName: string;
  /** 角色描述 */
  description: string;
  /** 状态 */
  status: string;
}

/** 用户信息 */
export interface UserInfo {
  /** 用户ID */
  userId: number;
  /** 用户ID (兼容后端可能使用的字段名) */
  id?: number;
  /** 用户名 */
  userName: string;
  /** 昵称 */
  nickName?: string;
  /** 手机号 */
  phonenumber?: string;
  /** 邮箱 */
  email?: string;
  /** 头像 */
  avatar?: string;
  /** 性别 0=男，1=女，2=未知 */
  sex?: string;
  /** 性别名称 */
  sexName?: string;
  /** 状态 0=禁用，1=启用 */
  status: number;
  /** 状态名称 */
  statusName: string;
  /** 登录IP */
  loginIp?: string;
  /** 登录时间 */
  loginDate?: string;
  /** 创建者 */
  createBy?: string;
  /** 创建时间 */
  createTime?: string;
  /** 更新者 */
  updateBy?: string;
  /** 更新时间 */
  updateTime?: string;
  /** 角色列表 */
  roles?: Role[];
  /** 角色名称 */
  roleNames?: string;
}

/** 分页查询参数 */
export interface UserPageQuery {
  /** 页码 */
  current?: number;
  /** 每页大小 */
  size?: number;
  /** 用户名（模糊查询） */
  userName?: string;
  /** 昵称（模糊查询） */
  nickName?: string;
  /** 邮箱（模糊查询） */
  email?: string;
  /** 手机号（模糊查询） */
  phonenumber?: string;
  /** 状态 */
  status?: number;
  /** 角色ID */
  roleId?: number;
  /** 性别 */
  sex?: string;
  /** 排序字段 */
  orderBy?: string;
  /** 排序方向 */
  orderDirection?: string;
}

/** 分页结果 */
export interface PageResult<T> {
  /** 记录列表 */
  records: T[];
  /** 总记录数 */
  total: number;
  /** 当前页 */
  current: number;
  /** 每页大小 */
  size: number;
  /** 总页数 */
  pages: number;
  /** 是否有上一页 */
  hasPrevious: boolean;
  /** 是否有下一页 */
  hasNext: boolean;
}

/** 用户分页查询结果 */
export type UserPageResult = ApiResponse<PageResult<UserInfo>>;

/** 用户详情结果 */
export type UserDetailResult = ApiResponse<UserInfo>;

/** 创建用户参数 */
export interface CreateUserRequest {
  /** 用户名 */
  userName: string;
  /** 昵称 */
  nickName?: string;
  /** 密码 */
  password: string;
  /** 手机号 */
  phonenumber?: string;
  /** 邮箱 */
  email?: string;
  /** 头像 */
  avatar?: string;
  /** 性别 */
  sex?: string;
  /** 状态 */
  status?: number;
  /** 角色ID列表 */
  roleIds?: number[];
}

/** 更新用户参数 */
export interface UpdateUserRequest {
  /** 昵称 */
  nickName?: string;
  /** 手机号 */
  phonenumber?: string;
  /** 邮箱 */
  email?: string;
  /** 头像 */
  avatar?: string;
  /** 性别 */
  sex?: string;
  /** 状态 */
  status?: number;
  /** 角色ID列表 */
  roleIds?: number[];
}

/** 重置密码参数 */
export interface ResetPasswordRequest {
  /** 新密码 */
  newPassword: string;
  /** 确认密码 */
  confirmPassword: string;
}

/** 更新状态参数 */
export interface UpdateStatusRequest {
  /** 状态 */
  status: number;
}

/** 检查结果 */
export type CheckResult = ApiResponse<boolean>;

/** 操作结果 */
export type OperationResult = ApiResponse;

// ==================== 辅助函数 ====================

/** 获取用户ID（兼容不同的字段名） - 增强版 */
export function getUserId(user: UserInfo | any): number {
  console.log("getUserId - 输入参数:", user);

  if (!user) {
    console.error("getUserId - 用户对象为空");
    return 0;
  }

  // 如果用户对象是数组，取第一个元素
  if (Array.isArray(user)) {
    console.log("getUserId - 检测到数组，取第一个元素");
    return getUserId(user[0]);
  }

  // 尝试多种可能的ID字段名（按优先级排序）
  const possibleIdFields = [
    "userId",
    "id",
    "user_id",
    "ID",
    "User_ID",
    "uid",
    "UID",
    "pkId",
    "pk_id",
    "PK_ID",
    "userID",
    "USER_ID",
    "Id",
    // 添加更多可能的后端字段名
    "user_pk",
    "userPk",
    "pk",
    "PK",
    "key",
    "KEY"
  ];

  console.log("getUserId - 检查字段:", possibleIdFields);

  // 第一轮：严格匹配数字类型
  for (const field of possibleIdFields) {
    if (user.hasOwnProperty(field)) {
      const value = user[field];
      console.log(
        `getUserId - 检查字段 ${field}:`,
        value,
        `(类型: ${typeof value})`
      );

      if (typeof value === "number" && value > 0) {
        console.log(`✅ getUserId - 找到有效的数字ID: ${field} = ${value}`);
        return value;
      }
    }
  }

  // 第二轮：字符串转数字
  for (const field of possibleIdFields) {
    if (user.hasOwnProperty(field)) {
      const value = user[field];
      if (typeof value === "string" && value.trim() !== "") {
        const numValue = Number(value);
        if (!isNaN(numValue) && numValue > 0) {
          console.log(
            `✅ getUserId - 找到有效的字符串ID: ${field} = ${numValue}`
          );
          return numValue;
        }
      }
    }
  }

  // 第三轮：遍历所有属性，查找可能的ID字段
  console.log("getUserId - 第三轮：遍历所有属性查找ID");
  const allEntries = Object.entries(user);

  // 优先查找包含'id'的字段
  for (const [key, value] of allEntries) {
    if (key.toLowerCase().includes("id")) {
      if (typeof value === "number" && value > 0) {
        console.log(`✅ getUserId - 通过属性名匹配找到ID: ${key} = ${value}`);
        return value;
      }
      if (
        typeof value === "string" &&
        !isNaN(Number(value)) &&
        Number(value) > 0
      ) {
        const numValue = Number(value);
        console.log(
          `✅ getUserId - 通过属性名匹配找到字符串ID: ${key} = ${numValue}`
        );
        return numValue;
      }
    }
  }

  // 第四轮：查找第一个有效的数字字段（可能是主键）
  console.log("getUserId - 第四轮：查找第一个有效数字字段");
  for (const [key, value] of allEntries) {
    if (typeof value === "number" && value > 0) {
      // 排除明显不是ID的字段
      const excludeFields = [
        "status",
        "sex",
        "age",
        "level",
        "score",
        "count",
        "total",
        "size",
        "length"
      ];
      if (!excludeFields.some(exclude => key.toLowerCase().includes(exclude))) {
        console.log(`🔄 getUserId - 使用第一个有效数字字段: ${key} = ${value}`);
        return value;
      }
    }
  }

  console.error("❌ getUserId - 无法找到有效的用户ID");
  console.error("用户对象的所有属性:", Object.keys(user));
  console.error("用户对象内容:", JSON.stringify(user, null, 2));

  // 提供调试建议
  console.log("🔧 调试建议：请在控制台运行以下命令检查数据结构：");
  console.log("window.realTimeDebug.checkCurrentUserData()");

  return 0;
}

// ==================== API 接口函数 ====================

/** 分页查询用户列表 */
export const getUserPageApi = (params: UserPageQuery) => {
  return http.request<UserPageResult>("get", "/admin/users/list", { params });
};

/** 查询用户详情 */
export const getUserDetailApi = (userId: number) => {
  console.log(`API调用: getUserDetailApi(${userId})`);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  // 确保userId是字符串类型
  const userIdStr = String(userId);
  console.log(`转换后的用户ID: ${userIdStr} (类型: ${typeof userIdStr})`);

  return http.request<UserDetailResult>(
    "get",
    `/admin/users/${userIdStr}/detail`
  );
};

/** 创建用户 */
export const createUserApi = (data: CreateUserRequest) => {
  console.log("API调用: createUserApi", data);
  return http.request<OperationResult>("post", "/admin/users/create", { data });
};

/** 更新用户信息 */
export const updateUserApi = (userId: number, data: UpdateUserRequest) => {
  console.log(`API调用: updateUserApi(${userId})`, data);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  // 确保userId是字符串类型
  const userIdStr = String(userId);
  console.log(`转换后的用户ID: ${userIdStr} (类型: ${typeof userIdStr})`);

  // 在请求体中也包含用户ID，以防后端需要
  const requestData = {
    ...data,
    userId: userId // 添加用户ID到请求体
  };

  console.log(`最终请求数据:`, requestData);

  return http.request<OperationResult>(
    "put",
    `/admin/users/${userIdStr}/update`,
    {
      data: requestData
    }
  );
};

/** 删除用户 */
export const deleteUserApi = (userId: number) => {
  console.log(`API调用: deleteUserApi(${userId})`);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }
  return http.request<OperationResult>(
    "delete",
    `/admin/users/${userId}/delete`
  );
};

/** 批量删除用户 */
export const batchDeleteUsersApi = (userIds: number[]) => {
  console.log("API调用: batchDeleteUsersApi", userIds);
  if (!userIds || userIds.length === 0) {
    console.error("无效的用户ID列表:", userIds);
    return Promise.reject(new Error("用户ID列表不能为空"));
  }
  return http.request<OperationResult>("delete", "/admin/users/batchDelete", {
    data: userIds
  });
};

/** 重置用户密码 */
export const resetUserPasswordApi = (
  userId: number,
  data: ResetPasswordRequest
) => {
  console.log(`API调用: resetUserPasswordApi(${userId})`, data);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  // 确保userId是字符串类型
  const userIdStr = String(userId);
  console.log(`转换后的用户ID: ${userIdStr} (类型: ${typeof userIdStr})`);
  console.log(`密码数据:`, data);

  // 在请求体中也包含用户ID，以防后端需要
  const requestData = {
    ...data,
    userId: userId // 添加用户ID到请求体
  };

  console.log(`最终请求数据:`, requestData);

  return http.request<OperationResult>(
    "put",
    `/admin/users/${userIdStr}/resetPassword`,
    {
      data: requestData
    }
  );
};

/** 启用/禁用用户 */
export const updateUserStatusApi = (userId: number, status: number) => {
  console.log(`API调用: updateUserStatusApi(${userId}, ${status})`);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  // 确保userId是字符串类型
  const userIdStr = String(userId);
  console.log(`转换后的用户ID: ${userIdStr} (类型: ${typeof userIdStr})`);
  console.log(`状态参数: ${status} (类型: ${typeof status})`);

  return http.request<OperationResult>(
    "put",
    `/admin/users/${userIdStr}/updateStatus`,
    {
      params: { status }
    }
  );
};

/** 检查用户名是否存在 */
export const checkUserNameApi = (userName: string, excludeUserId?: number) => {
  const params: any = { userName };
  if (excludeUserId) {
    params.excludeUserId = excludeUserId;
  }
  return http.request<CheckResult>("get", "/admin/users/checkUserName", {
    params
  });
};

/** 检查邮箱是否存在 */
export const checkEmailApi = (email: string, excludeUserId?: number) => {
  const params: any = { email };
  if (excludeUserId) {
    params.excludeUserId = excludeUserId;
  }
  return http.request<CheckResult>("get", "/admin/users/checkEmail", {
    params
  });
};

/** 检查手机号是否存在 */
export const checkPhoneApi = (phonenumber: string, excludeUserId?: number) => {
  const params: any = { phonenumber };
  if (excludeUserId) {
    params.excludeUserId = excludeUserId;
  }
  return http.request<CheckResult>("get", "/admin/users/checkPhone", {
    params
  });
};

/** 获取可用角色列表 */
export const getAvailableRolesApi = () => {
  console.log("API调用: getAvailableRolesApi");
  return http.request<ApiResponse<Role[]>>("get", "/admin/users/getRoles");
};

/** 为用户分配角色 */
export const assignRolesToUserApi = (userId: number, roleIds: number[]) => {
  console.log(`API调用: assignRolesToUserApi(${userId})`, roleIds);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  if (!Array.isArray(roleIds)) {
    console.error("角色ID必须是数组:", roleIds);
    return Promise.reject(new Error("角色ID必须是数组"));
  }

  return http.request<OperationResult>(
    "post",
    `/admin/users/${userId}/assignRoles`,
    { data: roleIds }
  );
};

/** 获取用户角色列表 */
export const getUserRolesApi = (userId: number) => {
  console.log(`API调用: getUserRolesApi(${userId})`);
  if (!userId || userId <= 0) {
    console.error("无效的用户ID:", userId);
    return Promise.reject(new Error("用户ID不能为空"));
  }

  return http.request<ApiResponse<Role[]>>(
    "get",
    `/admin/users/${userId}/getRoles`
  );
};
